package lei;

import com.google.gson.Gson;



import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @className: Demo01
 * @author: xl
 * @date: 2025/7/20 13:53
 * @Version: 1.0
 * @description:  泛型测试
 */

public class Main4 {


    public static void main(String[] args) {
        /**
         * 1、自定义泛型类<String> stringGeneric = new 自定义泛型类<>("Hello");
         */
        Box<Integer> intBox = new Box<>(42);
        var strBox = new Box<>("Hello");


        /**
         * 2、泛型方法
         */
        List<String> mutableNames = new ArrayList<>(List.of("Alice", "Bob"));
        String first = Utils.getFirst(mutableNames); // 自动推断为String
        System.out.println( first);




        /**
         * 5、类型限定（有界泛型）
         * 只接受Number及其子类
         */
        NumericBox<Integer> intBox1 = new NumericBox<>(10);
        NumericBox<Double> doubleBox2 = new NumericBox<>(3.14);

        // 使用下界通配符，T 必须是 Integer 或其父类
        List<Number> numberList = new ArrayList<>();;
        addNumbers(numberList);
        System.out.println("Number List: " + numberList); // 输出: Number List: [1, 2, 3, 4, 5]

        /**
         * 接受的列表元素必须是 Number 或其子类（如 Integer、Double 等）。
         */
        sum(numberList);


        /**
         * 接受任意类型的List
         */
        printList(numberList);


        /**
         * 7. 泛型与反射
         */
        // JSON字符串
        String json = "{\"name\":\"Alice\",\"age\":28}";

        // 创建解析器
        JsonParser parser = new JsonParser();

        // 泛型+反射解析
        User user = parser.parseJson(json, User.class);
        System.out.println(user); // 输出: User{name='Alice', age=28}


        /**
         *  8、函数式接口
         */
        TriFunction<Integer, Integer, Integer, Integer> sum = (a, b, c) -> a + b + c;
        int result = sum.apply(1, 2, 3); // 6

        /**
         * 9 、泛型单例工厂
         */
        // 获取单例实例
        MyService service1 = SingletonFactory.getInstance(DatabaseService.class);
        MyService service2 = SingletonFactory.getInstance(DatabaseService.class);

        // 验证单例
        System.out.println(service1 == service2); // 输出: true

        // 使用服务
        service1.execute(); // 输出: Database operation executed


    }

    /**
     * 6. 通配符类型
     *
     * @param list
     */
    // 接受任意类型的List
    public static void printList(List<?> list) {
        for (Object item : list) {
            System.out.println(item);
        }

    }

    // 上界通配符

    /**
     * 参数限制： 通过 List<? extends Number> 使用上界通配符，表示接受的列表元素必须是 Number 或其子类（如 Integer、Double 等）。
     * 核心操作： 遍历列表中的每个元素，调用 number.doubleValue() 将其统一转换为 double 类型，并进行累加求和。
     * 兼容性： 可安全处理多种数值类型的列表（如 List<Integer>、List<Double>），无需为每种类型单独实现方法。
     * @param numbers
     * @return
     */
    public static double sum(List<? extends Number> numbers) {
        return numbers.stream().mapToDouble(Number::doubleValue).sum();
    }

    /**
     * 使用下界通配符，T 必须是 Integer 或其父类
     * addNumbers(new ArrayList<Integer>());   // √ 自身
     * addNumbers(new ArrayList<Number>());    // √ 直接父类
     * addNumbers(new ArrayList<Object>());    // √ 祖先类
     * addNumbers(new ArrayList<Serializable>());// √ 实现的接口
     */
    public static void addNumbers(List<? super Integer> list) {
        for (int i = 1; i <= 5; i++) {
            list.add(i);
        }
    }

}


/**
 * 4、泛型接口
 *
 * @param <K>
 * @param <V>
 */
class Entry<K, V> implements Pair<K, V> {
    private K key;
    private V value;

    @Override
    public K getKey() {
        return null;
    }

    @Override
    public V getValue() {
        return null;
    }

    // 实现接口方法...
}

// 5. 只接受Number及其子类
class NumericBox<T extends Number> {
    private T value;

    public NumericBox() {
    }

    public NumericBox(T value) {
        this.value = value;
    }


    public double doubleValue() {
        return value.doubleValue();
    }


}





// JSON解析器（泛型+反射）
class JsonParser {
    private final Gson gson = new Gson();

    public <T> T parseJson(String json, Class<T> type) {
        return gson.fromJson(json, type);
    }
}


// 泛型单例工厂
class SingletonFactory {
    private static final ConcurrentHashMap<Class<?>, Object> instances = new ConcurrentHashMap<>();

    @SuppressWarnings("unchecked")
    public static <T> T getInstance(Class<T> type) {
        return (T) instances.computeIfAbsent(type, k -> {
            try {
                return type.getDeclaredConstructor().newInstance();
            } catch (Exception e) {
                throw new RuntimeException("Failed to create instance of " + type.getName(), e);
            }
        });
    }
}


/**
 * 10. 策略模式实现
 * 创建一个EmailValidator类，继承Validator抽象类，并实现validate方法
 */

class EmailValidator implements Validator<String> {
    @Override
    public boolean validate(String email) {
        return email.contains("@");
    }
}

class AgeValidator implements Validator<Integer> {
    @Override
    public boolean validate(Integer age) {
        return age >= 18;
    }
}


class User {
    private String name;
    private int age;

    // 必须有无参构造函数（反射需要）
    public User() {}

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter/Setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + "}";
    }
}

class DatabaseService implements MyService {
    @Override
    public void execute() {
        System.out.println("Database operation executed");
    }

    public void connect(String url) {
        System.out.println("Connecting to: " + url);
    }
}

class Utils {
    // 泛型方法
    public static <T> T getFirst(List<T> list) {
        return list.get(0);
    }
}


class Box<T> {
    private T content;

    public Box(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}


interface Pair<K, V> {
    K getKey();
    V getValue();
}

interface MyService {
    void execute();
}

@FunctionalInterface
interface TriFunction<A, B, C, R> {
    R apply(A a, B b, C c);
}


interface Validator<T> {
    boolean validate(T input);
}


















